Just Call Me Internet/Just Call Me Internet.iso/prog/atari/m2/cat3src/cat/edittool.i

Text File | 1997-10-26 | 65KB | 1,966 lines

IMPLEMENTATION MODULE EditTools;
(*$S-*)

FROM SYSTEM     IMPORT  ADDRESS, ADR, TSIZE, CADR, LOC, LONGWORD, CALLSYS;

(* Megamax-Lib *)

FROM Storage    IMPORT ALLOCATE, DEALLOCATE;

FROM GrafBase   IMPORT Rectangle, LongRect, Point;

IMPORT Strings, FileNames, BinOps, Block, StrConv, MOSGlobals, Keyboard, SysVars2;

FROM Keyboard  IMPORT SpecialCode;

(* MagicLib *)
IMPORT MagicAES, MagicDOS, MagicXBIOS, MagicSys, mtAlerts, mtAppl, mtDials, mtUtils;

(* CAT Module *)
FROM Void       IMPORT v;
IMPORT CatGlobal;
IMPORT WdwManager;

(* Editor  *)
FROM EditTypes  IMPORT EDITPTR, aLinePtr, aLineDesc, textPtr, aMark, deskSize, pixOff, undoType, TrennSet,
                       searchDir, CharSet, SuchModus, SuchFlags, theDrawLine, aBufferPtr, CAT, maxBlocks;

FROM EditGlobals        IMPORT  InqTextextend,  SetDocument, GetTextWidth,
                                ClipWork, MouseIsOn, CursorIsOn, HideCursor, ShowCursor, SaveMouse, RestoreMouse,
                                MouseCursor, ShowMouse, HideMouse, RowToIndex;

FROM EditDraw           IMPORT scrollRegion, drawLine, CenterCurrline, redrawLines, ShowBlockMark,
                               MarkArea;

IMPORT EditTypes;
IMPORT EditGlobals;
IMPORT EditBase;
IMPORT EditDraw;
IMPORT Find2;
IMPORT Varnames;
IMPORT ConfVars;

CONST    TAB     = 11C;

TYPE
     bigBufferPtr = POINTER TO ARRAY [0..$FFFFFFFF] OF CHAR;

TYPE undoBufferType = RECORD
                        whatToUndo   : undoType;
                        buffer       : bigBufferPtr;
                        bufSize      : LONGCARD;
                        oldStart,
                        oldEnd,
                        newStart,
                        newEnd       : aMark;
                        undoLine     : aLineDesc;
                        lines        : LONGINT;
                        atEndOfText  : BOOLEAN;
                        wdw          : INTEGER;
                      END;

VAR
    undoBuffer  : undoBufferType;
    undoList    : aLinePtr;
    saveLinePtr : aLinePtr;
    saveLineNr  : LONGINT;

    system,
    lastInfoLine : LONGCARD;
    lastInfoWin  : INTEGER;
    lastLine     : LONGINT;
    lastTotal    : LONGINT;
    lastRow      : INTEGER;
    lastInsert   : BOOLEAN;
    lastIndent   : BOOLEAN;

    (* Variablen fr Suchen und Ersetzen mit Wildcards *)

    (* In diesen Arrays wird fr jedes Wildcardzeichen gespeichert,
     * das wievielte Wildcardzeichen es insgesamt ist!
     *)
    allWildNumbers  : ARRAY [0..9] OF INTEGER;
    oneWildNumbers  : ARRAY [0..9] OF INTEGER;

    (* Das compilerte Suchpattern *)
    pPatt : Find2.tpPattern;
    ptrPatt : Find2.tpPat;

    (* Suchmuster initialisiert: *)
    searchInited: BOOLEAN;


PROCEDURE SystemTimer();
BEGIN
  system := SysVars2._hz_200;
END SystemTimer;

PROCEDURE SetInfoLine (ed : EDITPTR);
  VAR adr : RECORD a,b : ADDRESS; END;
      text: textPtr;
BEGIN
  IF ~ed^.showInfo THEN RETURN END;
  MagicXBIOS.Supexec (ADDRESS(SystemTimer));
  IF ((system < 100) OR (system - lastInfoLine > 100))
  &  ((lastInfoWin # ed^.wdw)  OR
      (ed^.currLineNr # lastLine) OR
      (ed^.currRow # lastRow) OR
      (ed^.autoIndent # lastIndent) OR
      (ed^.insertMode # lastInsert) OR
      (ed^.totalLineNr # lastTotal))
  THEN
    lastInfoLine := system;
    WITH ed^ DO
      lastLine := currLineNr;
      lastTotal := totalLineNr;
      lastRow := currRow;
      lastIndent := autoIndent;
      lastInsert := insertMode;
      lastInfoWin := wdw;
      IF ~readOnly OR listMode
      THEN
        Strings.Assign (' Zeile: ',WindowInfo, v.bool);
        Strings.Append (StrConv.IntToStr (currLineNr+1, 0), WindowInfo, v.bool);
        Strings.Append ('/', WindowInfo, v.bool);
        Strings.Append (StrConv.IntToStr (totalLineNr, 0), WindowInfo, v.bool);
        Strings.Append ('   Spalte: ', WindowInfo, v.bool);
        IF realTabs
        THEN
          v.bool := EditBase.GetLineAdr (ed, currLineNr, text, v.int);
          Strings.Append (StrConv.IntToStr (RowToIndex(text^, currRow, tabSize), 0), WindowInfo, v.bool);
        ELSE
          Strings.Append (StrConv.IntToStr (currRow, 0), WindowInfo, v.bool);
        END;
        IF insertMode THEN
          Strings.Append ('  Einfgen', WindowInfo, v.bool);
        ELSE
          Strings.Append ('  šberschreiben', WindowInfo, v.bool);
        END;
        IF autoIndent
        THEN
          Strings.Append ('/Einrcken', WindowInfo, v.bool);
        END;
      END;
      WdwManager.SetWdwInfoline (wdw, WindowInfo);
    END;
  END;
END SetInfoLine;

PROCEDURE SetEditTitle (ed : EDITPTR);
  VAR adr : RECORD a,b : ADDRESS; END;
BEGIN
  WITH ed^ DO
    IF ~readOnly
    THEN
      ConfVars.GetConfDefBool (cSetAppName, v.bool, TRUE);
      IF CatGlobal.multiTask & v.bool
      THEN
        (*$? CAT:
        Strings.Assign (' [CAT] ',WindowTitle, v.bool);
        *)
        (*$? NOT CAT:
        Strings.Assign (' [Fred] ',WindowTitle, v.bool);
        *)
      ELSE
        WindowTitle := '';
      END;
      (* Changed anzeigen mit '*' vor Dateinamen *)
      IF changed THEN Strings.Append ('*',WindowTitle, v.bool) END;
      IF fileName.length # 0
      THEN
        Strings.Append (fileName.text^, WindowTitle, v.bool);
      ELSE
        Strings.Append ('namenlos.txt', WindowTitle, v.bool);
      END;
      Strings.Append (' ', WindowTitle, v.bool);
    END;
    WdwManager.SetWdwTitle (wdw, WindowTitle);
  END;
END SetEditTitle;

PROCEDURE ShowFileChanged (ed : EDITPTR);
BEGIN
  IF ~ed^.changed & ~ed^.readOnly THEN
    ed^.changed := TRUE & ~ed^.readOnly;
    SetEditTitle(ed);
  END;
END ShowFileChanged;

PROCEDURE UpdateCurrLine (VAR ed : EDITPTR; line : LONGINT);
BEGIN
  WITH ed^ DO
    saveLineNr := -1;
    currLineNr := BinOps.HigherLInt (0, line);
    currLineNr := BinOps.LowerLInt (totalLineNr-1, line);
    v.bool := EditBase.GetLineLength (ed, currLineNr, editLen);
    IF editLen >= editLine.length
    THEN
      DEALLOCATE (editLine.text, 0);
      editLine.length := ((editLen + 16) DIV 16) * 16;
      ALLOCATE (editLine.text, editLine.length);
      IF editLine.text = NIL THEN
        (* Kein Speicher frei, kompaktieren *)
        v.bool := EditBase.CompactBuffer (ed);
        ALLOCATE (editLine.text, editLine.length);
        IF editLine.text = NIL THEN HALT END;
      END;
    END;
    Block.Clear (editLine.text, editLine.length);
    EditBase.GetCurrLine (ed, editLine.text^, editLen);
    editChanged := FALSE;
  END;
END UpdateCurrLine;

PROCEDURE SetCurrLine (VAR ed : EDITPTR; line : LONGINT);
BEGIN
  WITH ed^ DO
    IF line = currLineNr THEN RETURN END;
    line := BinOps.HigherLInt (0, line);
    line := BinOps.LowerLInt (totalLineNr-1, line);
    IF editChanged
    THEN
      (*
      IF editLen # INTEGER(LENGTH (editLine.text^)) THEN HALT END;
      *)
      v.bool := EditBase.PutCurrLine (ed);
      editChanged := FALSE;
    END;
    UpdateCurrLine (ed, line);
  END;
END SetCurrLine;

PROCEDURE SetStartLine (VAR ed : EDITPTR; line : LONGINT; docUpdate : BOOLEAN);
BEGIN
  WITH ed^ DO
    StartLine := BinOps.HigherLInt (0, line);
    StartLine := BinOps.LowerLInt (totalLineNr-1, line);
    StartLine := line;
    IF docUpdate THEN SetDocument (ed) END;
  END;
END SetStartLine;

        (* Abfrage-Funktionen           *)

PROCEDURE getCharPos (VAR ed : EDITPTR; line : LONGINT; row : INTEGER; VAR x, y : INTEGER);
VAR
      saveLine  : LONGINT;
      extend    : ARRAY [0..3] OF Point;
      saveCh    : CHAR;
      charAdr   : POINTER TO CHAR;
      restoreLine : BOOLEAN;
      text        : textPtr;
      len         : INTEGER;
BEGIN
  WITH ed^ DO
    IF line # currLineNr
    THEN
      restoreLine := TRUE;
      saveLine := currLineNr;
      SetCurrLine (ed, line);
    ELSE
      restoreLine := FALSE;
    END;
    y := editWork.y + SHORT(currLineNr - StartLine) * charHeight;
    IF row < 0 THEN x := editWork.x; RETURN END;
    IF ~monoSpaced OR realTabs OR parseEffects
    THEN
      (* So geht's schneller: *)
      v.bool := EditBase.GetLineAdr (ed, line, text, len);
(* Neu geschrieben fr Effekte
      IF row > len THEN row := len END;
      charAdr := ADR (text^[row]);
      saveCh := charAdr^;
      (* String terminieren *)
      charAdr^ := 0C;
      (* Cursorposition bestimmen *)
      IF realTabs
      THEN
        CatGlobal.ConvertTabs (text^, theDrawLine, tabSize);
        text := ADR(theDrawLine);
      END;
      InqTextextend (ed, text^, extend, TRUE);
      (* Žnderung wieder rckg„ngig machen *)
      charAdr^ := saveCh;
*)
      IF ~v.bool
      THEN
        x := 0;
        y := 0;
      ELSE
        charAdr := ADR (text^[len]);
        saveCh := charAdr^;
        (* String terminieren *)
        charAdr^ := 0C;
        (* Cursorposition bestimmen *)
        IF realTabs
        THEN
          CatGlobal.ConvertTabs (text^, theDrawLine, tabSize);
          row := RowToIndex (text^, row, tabSize);
          text := ADR(theDrawLine);
          len := LENGTH (theDrawLine);
        END;
        IF row > len THEN row := len END;
        (* Jetzt Breite bestimmen *)
        GetTextWidth (ed, text^, row, extend);
        charAdr^ := saveCh;
        (*----*)
        x := editWork.x + extend[1].x - extend[0].x + pixOff - leftOffset;
      END;
    ELSE
      x:= editWork.x + pixOff - leftOffset + row * charWidth;
    END;
    IF restoreLine
    THEN
      SetCurrLine (ed, saveLine);
    END;
  END (* WITH ed^ DO *)
END getCharPos;

(* Neues Konzept fr UNDO:
 * Es werden pro Datei 64 Operationen gemerkt. Eine Operation ist dabei
 * folgendes:
 *
 * - Einfgen eines Wortes (= alle Zeichen bis zu einem Space oder Befehl)
 * - Einfgen eines oder mehrerer Zeilenumbrche
 * - Einfgen, Ersetzen oder L”schen eines Blocks (oder Files)
 *
 * Implementation:
 * Es wird ein Array von Undobuffern implementiert, in dem die Operationen
 * alle festgehalten werden. Dieses Array stellt einen Ring dar, wobei ein
 * globaler Index festh„lt, welches Element das erste im Ring ist.
 * In jedem Undobuffer wird festgehalten, die wievielte Operation dies
 * im Ring ist, sowie alle ben”tigten Daten zur Rckg„ngigmachung der
 * Aktion. Dazu wird folgendes festgehalten:
 * Die Anzahl der Zeichen, die eingefgt oder gel”scht wurden.
 * Die Zeichen, die eingefgt oder gel”scht wurden (in einem Buffer)
 * Die aktuelle Cursorposition
 * Die Position der Blockmarken vor und nach der Operation
 *
 *
 * Da diese Operationen teilweise sehr speicherintensiv sein k”nnen,
 * ist es notwendig, einen Teil der Implementation in EditBase vorzunehmen,
 * damit bei einer Speicherknappheit die „ltesten Undooperationen
 * auch gel”scht werden k”nnen.
 * Da die Implementation pro Datei erfolgen soll, ist es notwendig, den
 * Undobuffer in den Typ EDITOR mit aufzunehmen. Dadurch w„chst der Platz-
 * bedarf der Editor-Struktur nochmal deutlich an.
 *)

(* (* neue Implementation, erstmal als Kommentar. *)
CONST   maxUndo = 32;

TYPE undoBufferType = RECORD
                        operationNr  : LONGCARD;
                        whatToUndo   : undoType;
                        buffer       : bigBufferPtr;
                        bufSize      : LONGCARD;
                        oldStart,
                        oldEnd,
                        newStart,
                        newEnd       : aMark;
                        wdw          : INTEGER;
                      END;

TYPE undoArrayType = ARRAY [0..maxUndo-1] OF undoBufferType;

TYPE undoDescriptor = RECORD
                        undoIndex   : INTEGER;
                        undoMax     : INTEGER;
                        undoBuffers : undoArrayType;
                        undoDone    : BOOLEAN;
                      END;



*)

PROCEDURE ClearUndoBuffer (); FORWARD;

PROCEDURE SaveLine(VAR l : aLinePtr; lNr : LONGINT);
BEGIN
  IF lNr # saveLineNr
  THEN
    IF saveLinePtr^.zeile.text # NIL THEN DEALLOCATE (saveLinePtr^.zeile.text, 0) END;
    IF l^.zeile.length < 0 THEN HALT END;
    ALLOCATE (saveLinePtr^.zeile.text, l^.zeile.length);
    IF saveLinePtr^.zeile.text = NIL
    THEN
      saveLineNr := -1;
      saveLinePtr^.zeile.length := 0;
    ELSE
      saveLineNr := lNr;
      saveLinePtr^.zeile.length := l^.zeile.length;
      Strings.Assign (l^.zeile.text^, saveLinePtr^.zeile.text^, v.bool);
    END;
    ClearUndoBuffer();
  END;
END SaveLine;

PROCEDURE PutInUndoList (line : aLinePtr);
BEGIN
  (* Zeile in Undopuffer h„ngen *)
  line^.next := undoList;
  line^.prev := NIL;
  undoList := line;
END PutInUndoList;

PROCEDURE DeleteLine (VAR ed : EDITPTR; redraw : BOOLEAN);
  VAR line : aLinePtr;
      cursOn : BOOLEAN;
      i      : INTEGER;
      scroll : BOOLEAN;
BEGIN
  WITH ed^ DO
    HideMouse();
    HideCursor (ed);
    ShowFileChanged (ed);
    scroll := TRUE;
    IF currLineNr = totalLineNr - 1 THEN
      (* Letzte Zeile: Nur Inhalt l”schen! *)
      editLine.text^ := 15C+12C+0C;
      editLen := 2;
      editChanged := TRUE;
      v.bool := EditBase.PutCurrLine (ed);
      EditDraw.redrawLine (ed, FALSE, TRUE);
    ELSE
      editChanged := FALSE;
      IF ~EditBase.DeleteLine (ed, currLineNr) THEN RETURN END;
      UpdateCurrLine (ed, currLineNr);
      IF redraw THEN
        (* Bildschirm neu aufbauen *)
        IF ((currLineNr - StartLine)+1 < LONG (windLines))
        THEN
          scrollRegion (ed, SHORT(currLineNr - StartLine), windLines, -1);
          (* drawLine (ed, windLines-1); *)
          (* drawLine (ed, windLines); *)
        ELSE
          (* nur unterste Zeile neu zeichnen *)
          drawLine (ed, windLines - 1);
        END;
      END; (* IF redraw *)
    END;
    SetDocument (ed);
    ShowCursor (ed);
    ShowMouse(FALSE);
  END; (* WITH ed^ *)
END DeleteLine;

PROCEDURE freeUndoBuffer();
BEGIN
  WITH undoBuffer DO
    DEALLOCATE (buffer, 0);
    bufSize := 0;
    IF undoLine.text # NIL THEN DEALLOCATE (undoLine.text, 0) END;
    undoLine.text := NIL;
    undoLine.text := NIL;
    buffer := NIL;
    lines := 0;
  END;
END freeUndoBuffer;

PROCEDURE ClearUndoBuffer();
BEGIN
  IF undoBuffer.whatToUndo # nothingToDo
  THEN
    freeUndoBuffer();
    undoBuffer.whatToUndo := nothingToDo;
  END;
END ClearUndoBuffer;

PROCEDURE CheckAndFreeUndo(wdw: INTEGER);
BEGIN
 IF wdw = undoBuffer.wdw
 THEN
   ClearUndoBuffer();
 END;
END CheckAndFreeUndo;

PROCEDURE FreeUndoBuffer();
BEGIN
  IF saveLinePtr^.zeile.text # NIL THEN DEALLOCATE (saveLinePtr^.zeile.text, 0) END;
  saveLineNr := -1;
  saveLinePtr^.zeile.length := 0;
  ClearUndoBuffer();
END FreeUndoBuffer;

PROCEDURE Undo (VAR ed : EDITPTR);
  VAR line : aLinePtr;
      tmp  : aLineDesc;
      cursOn : BOOLEAN;
      m1, m2 : aMark;
      secondBuff : bigBufferPtr;
      secondSize : LONGCARD;
      blEnd  : LONGINT;

BEGIN
  HideCursor (ed);
  WITH ed^ DO
    IF editChanged
    THEN
      editChanged := FALSE;
      UpdateCurrLine (ed, currLineNr);
    ELSE
      IF ed^.wdw # undoBuffer.wdw THEN
        CatGlobal.Bing(0);
        ShowCursor (ed);
        RETURN
      END;
      WITH undoBuffer DO
        CASE whatToUndo OF
          blockToChar,
          blockCut    : (* Es wird der gesicherte Block an der alten Stelle wieder eingefgt.
                         * Da die kompletten Start- und Endzeilen gesichert wurden, muž die
                         * aktuelle Zeile nur gesichert werden und dann gel”scht und dann der
                         * alte Block eingefgt werden
                         *)
                        (* Alte Position wieder herstellen *)
                        SetCurrLine (ed, oldStart.line);
                        (* Erstmal aktuelle Zeile in Undobuffer sichern *)
                        ALLOCATE (undoLine.text, editLine.length);
                        IF undoLine.text = NIL
                        THEN
                          whatToUndo := nothingToDo;
                        ELSE
                          undoLine.length := editLine.length;
                          Strings.Assign (editLine.text^, undoLine.text^, v.bool);
                          newStart.line := currLineNr;
                          newEnd.line   := currLineNr;
                          lines := 1;
                        END;
                        (* Aktuelle Zeile in Buffer schreiben (Datenkonsistenz) *)
                        v.bool := EditBase.PutCurrLine (ed);
                        ed^.currRow := oldStart.row;
                        (* Aktuelle und n„chste Zeile l”schen *)
                        IF ~atEndOfText
                        THEN
                          IF (currLineNr < totalLineNr - 1)  THEN
                            v.bool := EditBase.DeleteLine (ed, currLineNr+1);
                          END;
                        END;
                        v.bool := EditBase.DeleteLine (ed, currLineNr);
                        (* Undobuffer jetzt einkopieren *)
                        ed^.currLineNr := oldStart.line;
                        ed^.currRow := 0;
                        ed^.block := TRUE;
                        v.bool := EditBase.InsertBuffer (ed, buffer, bufSize, TRUE);
                        ed^.currRow := oldStart.row;
                        buffer := NIL;
                        bufSize := 0;
                        (* Jetzt neuen Undotyp setzen *)
                        IF (whatToUndo = blockCut) OR (whatToUndo = blockToChar)   (* kann vorher ver„ndert worden sein *)
                        THEN
                          whatToUndo := cutUndo
                        END;
                        (* Jetzt Blockmarken wiederherstellen *)
                        blocks[0].blockStart := oldStart;
                        blocks[0].blockEnd := oldEnd;
                        block := TRUE;
                        |
          blockPaste  : (* Vorgehensweise: Aktuellen Block sichern und dann ausschneiden,
                         * dann letzten Block wieder einfgen. Blockmarken umsetzen.
                         *)
                        WITH ed^ DO
                          IF (blocks[0].blockEnd.line < 0) OR (blocks[0].blockStart.line < 0) THEN
                            ShowCursor (ed);
                            RETURN
                          END;
                          newStart := blocks[0].blockStart;
                          newEnd   := blocks[0].blockEnd;
                          (* gesamten Block duplizieren *)
                          IF ~EditBase.CopyToBuff (ed, blocks[0].blockStart.line, blocks[0].blockEnd.line+1, secondBuff, secondSize)
                          THEN
                            whatToUndo := nothingToDo;
                          END;
                          (* Jetzt diesen Block ausschneiden! *)
                          IF blocks[0].blockEnd.line >= totalLineNr-1
                          THEN
                            blEnd := blocks[0].blockEnd.line
                          ELSE
                            blEnd := blocks[0].blockEnd.line + 1;
                          END;
                          v.bool := EditBase.DeleteSomeLines (ed, blocks[0].blockStart.line, blEnd);
                          (* Und jetzt den alten wieder einfgen *)
                          SetCurrLine (ed, oldStart.line);
                          currRow := oldStart.row;
                          (* Undobuffer jetzt einkopieren *)
                          v.bool := EditBase.InsertBuffer (ed, buffer, bufSize, TRUE);
                          currRow := oldStart.row;
                          IF whatToUndo = blockPaste THEN
                            buffer := secondBuff;
                            bufSize := secondSize;
                          ELSE
                            buffer := NIL;
                            bufSize := 0;
                          END;
                          (* Blockmarken setzen *)
                          blocks[0].blockStart := oldStart;
                          blocks[0].blockEnd   := oldEnd;
                          (* Jetzt noch Blockmarken swappen, falls blockPaste *)
                          IF (whatToUndo = blockPaste)
                          THEN
                            m1 := newStart;
                            newStart := oldStart;
                            oldStart := m1;
                            m1 := newEnd;
                            newEnd := oldEnd;
                            oldEnd := m1;
                          END;
                          (* SaveOp fr n„chstes Undo setzen *)
                          block := TRUE;
                        END; |
                        |
          cutUndo,
          normalPaste : (* Blockbereich komplett l”schen und einfach alte Zeile restaurieren *)
                        (* gesamten Block duplizieren *)
                        SetCurrLine (ed, oldStart.line);
                        IF oldEnd.line >= totalLineNr-1
                        THEN
                          blEnd := oldEnd.line;
                        ELSE
                          blEnd := oldEnd.line + 1;
                        END;
                        DEALLOCATE (buffer,0);
                        buffer := NIL;
                        bufSize := 0;
                        IF ~EditBase.CopyToBuff (ed, oldStart.line, blEnd, buffer, bufSize)
                        THEN
                          whatToUndo := nothingToDo;
                          freeUndoBuffer();
                          ShowCursor (ed);
                          RETURN
                        END;

                        (* Blockbereich l”schen *)
                        v.bool := EditBase.DeleteSomeLines (ed, oldStart.line, oldEnd.line);
                        (* Alte gesicherte Zeile einfgen *)
                        v.bool := EditBase.InsertLine (ed, oldStart.line, undoLine.text^, TRUE, LENGTH (undoLine.text^));
                        whatToUndo := blockCut;
                        currRow := oldStart.row;
                        DEALLOCATE (undoLine.text, 0);
                        block := FALSE;
                        blocks[0].blockStart.line := -1;
                        blocks[0].blockEnd.line := -1;

                        |
        ELSE
        END (* CASE whatToUndo OF *);
      END (* WITH undoBuffer *);
      UpdateCurrLine (ed, currLineNr);
      SetDocument (ed);
    END; (* IF editChanged *)
    currRow := BinOps.HigherInt (0, BinOps.LowerInt (editLen, currRow));
    EditGlobals.FixCursorPos (ed);
    (*
    countLines();
    *)
    ed^.cursPos.row := -1;   (* Neue Positionsberechnung fr Cursor erzwingen *)
    ShowFileChanged (ed);
    WdwManager.RedrawWdw (ed^.wdw, ed^.editWork);
    CenterCurrline (ed);
    SetDocument (ed);
  END;
  ShowCursor (ed);
END Undo;

PROCEDURE SaveOp (ed : EDITPTR; op : undoType; append : BOOLEAN);
  VAR clLine,
      blEnd,
      lastLine : LONGINT;
      clRow : INTEGER;
      line  : aLinePtr;
      argPtr : POINTER TO ARRAY[0..1] OF aMark;
BEGIN
(*        undoType   = (blockToChar, charToBlock, blockCut, cutUndo, blockPaste, normalPaste, lineDel, nothingToDo); *)
  WITH ed^ DO
    v.bool := EditBase.PutCurrLine (ed);
    WITH undoBuffer DO
      whatToUndo := op;
      saveLineNr := -1;
      undoBuffer.wdw := ed^.wdw;
      CASE op OF
        blockPaste,
        blockCut,
        blockToChar : IF (blocks[0].blockStart.line < 0) OR (blocks[0].blockEnd.line < 0) OR (blocks[0].blockEnd.line < blocks[0].blockStart.line) THEN RETURN END;
                      (* alten Undobuffer freigeben, wird nicht mehr gebraucht! *)
                      freeUndoBuffer ();
                      (* Blockmarken merken *)
                      oldStart := blocks[0].blockStart;
                      oldEnd  := blocks[0].blockEnd;
                      (* gesamten Block duplizieren *)
                      IF blocks[0].blockEnd.line >= totalLineNr-1
                      THEN
                        blEnd := blocks[0].blockEnd.line;
                        atEndOfText := TRUE;
                      ELSE
                        blEnd := blocks[0].blockEnd.line + 1;
                        atEndOfText := FALSE;
                      END;
                      IF ~EditBase.CopyToBuff (ed, blocks[0].blockStart.line, blEnd, buffer, bufSize)
                      THEN
                        whatToUndo := nothingToDo;
                        freeUndoBuffer();
                        RETURN
                      END;
                      (* Cursorposition restaurieren *)
                      |
        normalPaste : (* erstmal alten buffer freigeben, wird nicht mehr gebraucht
                       *)
                      freeUndoBuffer ();
                      (* Kann ich nicht so leicht machen, bessere Idee gehabt:
                       * nachher noch einen Aufruf mit den entsprechenden Werten in den BlockMarken
                       * Die sollten sowieso drin sein, da die auch bei blockPaste drinstehen mssen.
                       *)
                      (* Ich muž mir nur die aktuelle Zeile merken, falls die gesplittet wird *)
                      (* currLine merken und undoBuffer darauf setzen! *)
                      IF undoLine.text # NIL THEN DEALLOCATE (undoLine.text, 0) END;
                      ALLOCATE (undoLine.text, editLine.length);
                      IF undoLine.text = NIL
                      THEN
                        whatToUndo := nothingToDo;
                        RETURN
                      ELSE
                        undoLine.length := editLine.length;
                      END;
                      Strings.Assign (editLine.text^, undoLine.text^, v.bool);
                      newStart.line := currLineNr;
                      newEnd.line := currLineNr;
                      lines := 1;
                      |
      ELSE
        (* empty ELSE for CASE *)
      END (* CASE op OF *);
    END;
  END; (* WITH ed^ DO *)
END SaveOp;

PROCEDURE NewBlockToUndoBuffer (VAR ed : EDITPTR);
BEGIN
  WITH ed^ DO
    WITH undoBuffer DO
      CASE whatToUndo OF
        blockPaste : newStart := blocks[0].blockStart; newEnd := blocks[0].blockEnd; |
        normalPaste : oldStart := blocks[0].blockStart; oldEnd := blocks[0].blockEnd; |
      ELSE
      END; (* CASE *)
    END;
  END;
END NewBlockToUndoBuffer;

PROCEDURE PossibleUndo (ed: EDITPTR): BOOLEAN;
BEGIN
  RETURN ed^.editChanged OR ((ed^.wdw = undoBuffer.wdw) & (undoBuffer.whatToUndo # nothingToDo));
END PossibleUndo;

        (* Blockfunktionen I *)

PROCEDURE SetBlockstart (VAR ed : EDITPTR);
  VAR oldLine : LONGINT;
      oldRow  : INTEGER;

  PROCEDURE Unmark();
  BEGIN
    WITH ed^ DO
      blocks[0].blockStart.line := oldLine;
      blocks[0].blockStart.row := oldRow;
      ShowBlockMark (ed, TRUE);
      blocks[0].blockStart.line := currLineNr;
      blocks[0].blockStart.row := currRow;
    END;
  END Unmark;

BEGIN
  WITH ed^ DO
    IF multiBlockIdx > 0 THEN RETURN END;
    WITH blocks[0].blockStart DO
      oldLine := line;
      oldRow  := row;
      line := currLineNr;
      row  := currRow;
    END;
    IF blocks[0].blockEnd.line >= blocks[0].blockStart.line
    THEN
      IF oldLine >= 0
      THEN
        (* Block erweitern *)
        Unmark();
        ShowBlockMark (ed, TRUE);
      ELSE
        ShowBlockMark (ed, TRUE);
      END;
    ELSE
      IF blocks[0].blockEnd.line >= oldLine
      THEN
        (* alten Block l”schen *)
        Unmark();
      END;
    END;
  END; (* WITH ed^ DO *)
END SetBlockstart;

PROCEDURE SetBlockend (VAR ed : EDITPTR);
  VAR oldLine : LONGINT;
      oldRow  : INTEGER;

  PROCEDURE Unmark();
  BEGIN
    WITH ed^ DO
      blocks[0].blockEnd.line := oldLine;
      blocks[0].blockEnd.row := oldRow;
      ShowBlockMark (ed, TRUE);
      blocks[0].blockEnd.line := currLineNr;
      blocks[0].blockEnd.row := currRow;
    END;
  END Unmark;

BEGIN
  WITH ed^ DO
    IF multiBlockIdx > 0 THEN RETURN END;
    WITH blocks[0].blockEnd DO
      oldLine := line;
      oldRow  := row;
      line := currLineNr;
      row  := currRow;
    END;
    IF blocks[0].blockEnd.line >= blocks[0].blockStart.line
    THEN
      IF (oldLine >= 0) & (blocks[0].blockStart.line >= 0)
      THEN
        (* Block erweitern *)
        Unmark;
        ShowBlockMark (ed, TRUE);
      ELSE
        ShowBlockMark (ed, TRUE);
      END;
    ELSE
      IF oldLine >= blocks[0].blockStart.line
      THEN
        (* alte Blockmarkierung l”schen *)
        Unmark();
      END;
    END;
  END; (* WITH ed^ DO *)
END SetBlockend;

PROCEDURE ClearBlock (VAR ed : EDITPTR);
(* L”scht Blockmarkierung *)
  VAR i : INTEGER;
BEGIN
  ShowBlockMark (ed, TRUE);
  WITH ed^ DO
    FOR i := 0 TO maxBlocks - 1 DO
      WITH blocks[i] DO
        blockStart.line := -1;
        blockEnd.line := -1;
      END;
    END;
    multiBlockIdx := -1;
    block := FALSE;
  END;
END ClearBlock;

PROCEDURE GetClickLineAndRow (ed : EDITPTR; x, y : INTEGER; VAR clLine : LONGINT; VAR clRow : INTEGER);
VAR extend    : ARRAY [0..3] OF Point;
    ch  : ARRAY [0..1] OF CHAR;
    saveCh : CHAR;
    charAdr : POINTER TO CHAR;
    sl:       INTEGER;
    text:     textPtr;
    i, j:     INTEGER;
    takeLast: BOOLEAN;
    xSub:     INTEGER;
BEGIN
  WITH ed^ DO
    (* Feststellen, in welche Zeile geklickt wurde *)
    clLine := StartLine + LONG((y - editWork.y) DIV charHeight);
    IF clLine < 0 THEN clLine := 0; clRow := 0; RETURN END;
    IF clLine > totalLineNr - 1 THEN
      clLine := totalLineNr - 1;
      takeLast := TRUE;
    ELSE
      takeLast := FALSE;
    END;
    (* Zeile zur aktuellen machen *)
    SetCurrLine (ed, clLine);
    (* Jetzt Spalte bestimmen *)
    IF ~insertMode
    THEN
      IF monoSpaced THEN
        xSub := charWidth DIV 2;
      ELSE
        xSub := 0;
      END;
    ELSE
      xSub := 0;
    END;
    INC (x, pixOff);                                         (* PixelOffset addieren *)
    clRow := (x + leftOffset - editWork.x-xSub) DIV charWidth;

    sl := editLen;
    IF clRow < 0 THEN clRow := 0 END;
    (* clRow ist nur N„herung, mal suchen gehen *)
    IF takeLast THEN
      currRow := sl;
      EditGlobals.FixCursorPos (ed);
      clRow := currRow;
      RETURN
    END;
    IF realTabs
    THEN
      CatGlobal.ConvertTabs (editLine.text^, theDrawLine, tabSize);
      text := ADR(theDrawLine);
      sl := (*SYSTEM.*)LENGTH (text^);
    ELSE
      text := editLine.text;
    END;
    clRow :=BinOps.HigherInt (0, BinOps.LowerInt (clRow, sl));
    IF x <= editWork.x THEN
      clRow := 0 (* Sonderfall! *)
    ELSIF ~monoSpaced OR parseEffects
    THEN
      (* Nachsehen, ob berechnete Position zu klein! *)
      REPEAT
        IF (clRow < sl)
        THEN
          INC(clRow);
(*
          (* So geht's schneller: *)
          charAdr := ADR (text^[clRow]);
          saveCh := charAdr^;
          (* String terminieren *)
          charAdr^ := 0C;
          (* Cursorposition bestimmen mit eigener Funktion wegen Attributen *)
          InqTextextend (ed, text^, extend, TRUE);
          (* Žnderung wieder rckg„ngig machen *)
          charAdr^ := saveCh;
*)
          GetTextWidth (ed, text^, clRow, extend);
        END;
      UNTIL ((x-editWork.x+leftOffset) < (extend[1].x - extend[0].x)) OR (clRow >= sl);
      INC (clRow);
      REPEAT
        DEC (clRow);
        IF (clRow > 0) & (clRow <= sl)
        THEN
(*
          (* So geht's schneller: *)
          charAdr := ADR (text^[clRow]);
          saveCh := charAdr^;
          (* String terminieren *)
          charAdr^ := 0C;
          (* Cursorposition bestimmen *)
          InqTextextend (ed, text^, extend, TRUE);
          (* Žnderung wieder rckg„ngig machen *)
          charAdr^ := saveCh;
*)
          GetTextWidth (ed, text^, clRow, extend);
        END;
      UNTIL ((x-editWork.x+leftOffset) > (extend[1].x - extend[0].x)) OR (clRow = 0);
    END;
    clRow := BinOps.LowerInt (clRow, sl);
    IF realTabs
    THEN
      v.bool := EditBase.GetLineAdr (ed, currLineNr, text, sl);
      j := 0;
      i := 0;
      WHILE j <= clRow DO
        IF text^[i] = TAB
        THEN
          j := ((j DIV tabSize)+1)*tabSize;
        ELSE
          INC(j);
        END;
        INC(i);
      END;
      IF i > 0 THEN clRow := i-1 ELSE clRow := i; END;
    END;
    (* Jetzt noch CR abfangen *)
    IF (clRow > 0) & (text^[clRow-1] = 15C)
    THEN
      DEC (clRow);
    END;
    currRow := clRow;
    EditGlobals.FixCursorPos (ed);
    clRow := currRow;
  END (* WITH ed^ DO *)
END GetClickLineAndRow;

PROCEDURE TestBlockMarksAndSwap (ed : EDITPTR);
  CONST  wordEnds = CharSet {0C, 12C, 15C, ' ','.',',',';','!','-','?',':','"',"'",'}',']',')'};
  VAR i, j : INTEGER;
      bl   : INTEGER;
BEGIN
  WITH ed^ DO
    FOR bl := 0 TO maxBlocks - 1 DO
      IF (blocks[bl].blockStart.line >= 0) & (blocks[bl].blockEnd.line >= 0)
      THEN
        IF blocks[bl].blockEnd.line < blocks[bl].blockStart.line
        THEN
          v.lint := blocks[bl].blockEnd.line;
          blocks[bl].blockEnd.line := blocks[bl].blockStart.line;
          blocks[bl].blockStart.line := v.lint;
          v.int := blocks[bl].blockEnd.row;
          blocks[bl].blockEnd.row := blocks[bl].blockStart.row;
          blocks[bl].blockStart.row := v.int;
        ELSIF (blocks[bl].blockEnd.line = blocks[bl].blockStart.line) & (blocks[bl].blockEnd.row < blocks[bl].blockStart.row)
        THEN
          v.int := blocks[bl].blockEnd.row;
          blocks[bl].blockEnd.row := blocks[bl].blockStart.row;
          blocks[bl].blockStart.row := v.int;
        END;
        (* Jetzt noch Spezialbehandlung fr Effekte *)
        IF parseEffects & (blocks[bl].blockStart.row > 0)
        THEN
          SetCurrLine (ed, blocks[bl].blockStart.line);
          IF editLine.text^[blocks[bl].blockStart.row-1] IN CharSet {'*','/','_'}
          THEN
            (* Check for second occurence of effect char in line *)
            i := blocks[bl].blockStart.row-1;
            j := i;
            REPEAT
              REPEAT
                INC(j);
              UNTIL (j >= editLen) OR (editLine.text^[j] = editLine.text^[i]);
            UNTIL (j >= editLen) OR (editLine.text^[j+1] IN wordEnds);
            IF j < editLen
            THEN
              (* Ok, wirklich ein Effektzeichen, also hinzunehmen *)
              DEC (blocks[bl].blockStart.row);
            END;
          END;
        END;
      END;
    END;
  END;
END TestBlockMarksAndSwap;

PROCEDURE ToWordEnd (ed : EDITPTR; line : LONGINT; row : INTEGER) : INTEGER;
VAR l, z : INTEGER;
    text : textPtr;
BEGIN
  WITH ed^ DO
    IF ~EditBase.GetLineAdr (ed, line, text, l)
    THEN
      RETURN row
    END;
    IF (l > 0) & (text^[l-1] = 15C) THEN DEC (l) END;
    z := row;
    WHILE (z < l) & ~(text^[z] IN TrennSet) DO INC (z) END;
    IF (z < l) & (text^[z] IN CharSet{'*','/','_'}) THEN INC (z) END;
    RETURN z
  END;
END ToWordEnd;

PROCEDURE ToWordStart (ed : EDITPTR; line : LONGINT; row : INTEGER) : INTEGER;
VAR l, z   : INTEGER;
    text : textPtr;
BEGIN
  WITH ed^ DO
    IF ~EditBase.GetLineAdr (ed, line, text, l)
    THEN
      RETURN row
    END;
    z := BinOps.LowerInt (l, row);
    WHILE (z > 0) & ~(text^[z] IN TrennSet) DO DEC (z) END;
    IF (z # 0) & (z+1 < row) THEN INC(z); END;
(*    IF (z+1 < row) THEN INC(z); END; *)
    IF (z > 0) & (text^[z-1] IN CharSet{'*','/','_'}) THEN DEC (z) END;
    RETURN z
  END;
END ToWordStart;

PROCEDURE ToLineStart (ed: EDITPTR; line: LONGINT): INTEGER;
BEGIN
  (* Ist nur gedacht fr andere m”gliche Implementationen, deshalb
   * als Funktion
   *)
  RETURN 0;
END ToLineStart;

PROCEDURE ToLineEnd (ed: EDITPTR; line: LONGINT): INTEGER;
(* Gibt die Cursorposition fr das Zeilenende zurck *)
  VAR cRow,
      ret   : INTEGER;
BEGIN
  WITH ed^ DO
    cRow := currRow;
    IF EditBase.GetLineLength (ed, currLineNr, currRow)
    THEN
      EditGlobals.FixCursorPos (ed);
      ret := currRow;
    ELSE
      ret := cRow
    END;
    currRow := cRow;
  END;
  RETURN ret;
END ToLineEnd;

PROCEDURE MarkLine (ed : EDITPTR);
  VAR clRow,
      l : INTEGER;
      cLine: LONGINT;
BEGIN
  WITH ed^ DO
    clRow := currRow;
    currRow := 0;
    SetBlockstart (ed);
    IF currLineNr = totalLineNr - 1
    THEN
      v.bool := EditBase.GetLineLength (ed, currLineNr, currRow);
      EditGlobals.FixCursorPos (ed);
      SetBlockend (ed);
    ELSE
      cLine := currLineNr;
      SetCurrLine (ed, currLineNr+1);
      SetBlockend (ed);
      SetCurrLine (ed, cLine);
    END;
    currRow := clRow;
    block := TRUE;
  END; (* WITH ed^ DO *)
END MarkLine;

PROCEDURE MarkWord (VAR ed : EDITPTR);
  TYPE wordRange = (all, line);

  VAR clRow : INTEGER;
      clLine : LONGINT;
      opChar,
      ch     : CHAR;
      text   : textPtr;
      l, depth,
      i      : INTEGER;
      found  : BOOLEAN;
      dir    : searchDir;
      range  : wordRange;
BEGIN
  WITH ed^ DO
    clRow := currRow;
    clLine := currLineNr;
    (* Feststellen, welches Zeichen unter Cursor ist *)
    ch := editLine.text^[currRow];
    found := FALSE;
    IF ch IN CharSet{'{','[','(','"',"'",')',']','}'}
    THEN (* Ist Klammerzeichen *)
      (* gegengesetztes Zeichen feststellen *)
      CASE ch OF
        '{' : opChar := '}'; dir := forward; range := all; |
        '}' : opChar := '{'; dir := backward; range := all; |
        '(' : opChar := ')'; dir := forward; range := all; |
        ')' : opChar := '('; dir := backward; range := all; |
        '[' : opChar := ']'; dir := forward; range := all; |
        ']' : opChar := '['; dir := backward; range := all; |
        "'",
        '"' : opChar := ch; range := line; |
      ELSE
      END;
      IF range = line
      THEN
        (* nur aktuelle Zeile durchsuchen, vorrangig vorw„rts! *)
        text := editLine.text;
        l := editLen;
        INC(currRow);
        LOOP
          IF currRow >= l THEN EXIT END;
          IF text^[currRow] = opChar THEN found := TRUE; EXIT END;
          INC(currRow);
        END;
        IF ~found & (currRow > 0) THEN
          (* Rckw„rts suchen *)
          currRow := clRow -1;
          LOOP
            IF currRow < 0 THEN EXIT END;
            IF text^[currRow] = opChar THEN found := TRUE; EXIT END;
            DEC(currRow);
          END;
        END;
        IF ~found
        THEN currRow := clRow;
        ELSE
          block := TRUE;
          IF currRow < clRow THEN
            SetBlockstart (ed);
            currRow := clRow+1;
            SetBlockend (ed);
          ELSE
            INC (currRow);
            SetBlockend (ed);
            currRow := clRow;
            SetBlockstart (ed);
          END
        END;
      ELSE (* range = all *)
        depth := 0;
        IF dir = forward
        THEN
          INC(currRow);
          LOOP (* 1 *)
            text := editLine.text;
            l := editLen;
            LOOP (* 2, in Zeile *)
              IF (text^[currRow] = opChar)
              THEN
                IF depth = 0
                THEN found := TRUE; EXIT (* 2 *)
                ELSE
                  DEC (depth);
                END;
              ELSIF (text^[currRow] = ch)
              THEN
                INC (depth);
              END;
              IF currRow >= l
              THEN EXIT (* 2 *)
              END;
              INC(currRow);
            END; (* LOOP 2 *)
            IF found THEN EXIT  (* 1 *) END;
            IF currLineNr = totalLineNr - 1 THEN EXIT (* 1 *)
            ELSE
              SetCurrLine (ed, currLineNr + 1);
              currRow := 0;
            END;
          END; (* LOOP 1 *)
          IF found
          THEN
            INC (currRow);
            SetBlockend (ed);
            SetCurrLine (ed, clLine);
            currRow := clRow;
            SetBlockstart (ed);
            block := TRUE
          END;
        ELSE (* dir = backward *)
          DEC (currRow);
          text := editLine.text;
          LOOP (* 1 *)
            LOOP (* 2, in Zeile *)
              IF currRow < 0
              THEN EXIT (* 2 *)
              END;
              IF (text^[currRow] = opChar)
              THEN
                IF depth = 0
                THEN found := TRUE; EXIT (* 2 *)
                ELSE
                  DEC (depth);
                END;
              ELSIF (text^[currRow] = ch)
              THEN
                INC (depth);
              END;
              DEC(currRow);
            END; (* LOOP 2 *)
            IF found THEN EXIT  (* 1 *) END;
            IF currLineNr = 0 THEN EXIT (* 1 *)
            ELSE
              SetCurrLine (ed, currLineNr - 1);
              l := editLen;
              WHILE (l>0) & (ORD(text^[l-1]) < 20) DO DEC (l) END;
              IF l > 0 THEN currRow := l-1 ELSE currRow := l; END;
            END;
          END;
          IF found
          THEN
            SetBlockstart (ed);
            SetCurrLine (ed, clLine);
            currRow := clRow+1;
            SetBlockend (ed);
            block := TRUE
          END;
        END; (* IF dir *)
      END; (* IF range *)
    END; (* IF ch IN klammern *)
    IF ~found
    THEN
      SetCurrLine (ed, clLine);
      currRow := clRow;
      currRow := ToWordEnd (ed, currLineNr, currRow);
      SetBlockend (ed);
      IF currRow > 0 THEN DEC (currRow) END;
      currRow := ToWordStart (ed, currLineNr, currRow);
      SetBlockstart (ed);
      block := TRUE;
    END;
  END (* WITH ed^ DO *);
END MarkWord;

PROCEDURE MarkBlock (VAR ed : EDITPTR; ox, oy : INTEGER; init: BOOLEAN; fromTop: BOOLEAN);
(* Wird mit gedrckter linker Taste aufgerufen, bernimmt die Blockmarkierung
 *)
VAR
    b       : BITSET;
    mouse   : BOOLEAN;
    clip,
    work    : Rectangle;
    newLine,
    oldLine : LONGINT;
    oldX,
    oldY,
    charX,
    charY,
    oldRow,
    oldPixRow,
    newPixRow,
    newRow  : INTEGER;
    newEnd,
    newStart,
    saveEnd,
    saveStart : aMark;
    mx, my  : INTEGER;
    blockRects : ARRAY [0..2] OF Rectangle;
    i, j    : INTEGER;
    lines   : INTEGER;
    isRight,
    isLeft,
    oldIsRight,
    oldIsLeft   : BOOLEAN;

BEGIN
  (* Arbeitsweise: Invertiert den von der Maus berstrichenen Bereich und scrollt notfalls das Fenster.
   * Dabei wird jeweils der Block neu festgestellt, damit das auch beim Scrollen noch funktioniert.
   *)
  WITH ed^ DO
    (* Erst mal die Maus anschalten und auf Textcursor setzen *)
    SaveMouse;
    MouseCursor;
    ShowMouse (TRUE);
    MagicAES.WindUpdate (MagicAES.BEGMCTRL);    (* Wir haben jetzt die komplette Mauskontrolle          *)
    ClipWork (ed);                              (* Clipping auf Work-bereich vom Editor legen           *)
    work := editWork;                           (* Work-Bereich als xy-Paar berechnen                   *)
    work.w := work.x + work.w - 1;
    work.h := work.y + work.h - 1;
    GetClickLineAndRow (ed, ox, oy, oldLine, oldRow);
    newStart := blocks[0].blockStart;
    newEnd   := blocks[0].blockEnd;
    IF init
    THEN
      saveStart:= blocks[0].blockStart;
      saveEnd  := blocks[0].blockEnd;
    ELSE
      IF fromTop
      THEN
        saveStart:= blocks[0].blockStart;
        oldRow := blocks[0].blockEnd.row;
        oldLine := blocks[0].blockEnd.line;
        IF wordBlock
        THEN
          saveEnd.line := saveStart.line;
          saveEnd.row := ToWordEnd (ed, saveEnd.line, saveStart.row);
        ELSIF lineBlock
        THEN
          IF saveStart.line < totalLineNr - 1
          THEN
            saveEnd.line := saveStart.line + 1;
            saveEnd.row := ToLineStart (ed, saveEnd.line);
          ELSE
            saveEnd.line := saveStart.line;
            saveEnd.row := ToLineEnd (ed, saveEnd.line);
          END;
        END;
      ELSE
        saveEnd:= blocks[0].blockEnd;
        oldRow := blocks[0].blockStart.row;
        oldLine := blocks[0].blockStart.line;
        IF wordBlock
        THEN
          saveStart.line := saveEnd.line;
          saveStart.row := ToWordStart (ed, saveStart.line, saveEnd.row);
          IF (saveStart.row = saveEnd.row) & (saveStart.row > 0)
          THEN
            saveStart.row := ToWordStart (ed, saveStart.line, saveStart.row - 1);
          END;
        ELSIF lineBlock
        THEN
          IF saveEnd.line > 0
          THEN
            saveStart.line := saveEnd.line - 1;
            saveStart.row := ToLineStart (ed, saveStart.line);
          ELSE
            saveStart.line := 0;
            saveStart.row := ToLineStart (ed, saveStart.line);
          END;
        END;
      END;
    END;
    getCharPos (ed, oldLine, oldRow, oldPixRow, v.int);
    MagicAES.GrafMkstate (mx, my, b, v.bset);
    REPEAT
      IF my < work.y
      THEN
        (* Oberhalb vom Work-Bereich, scrollen *)
        (* Und jetzt scrollen, eigentlich sollte der Rest funktionieren *)
        IF my + 2*charHeight < work.y
        THEN lines := 5
        ELSIF my + charHeight  < work.y
        THEN lines := 3
        ELSE lines := 1;
        END;
        HideMouse();
        WdwManager.ScrollUp (ed^.wdw, lines);
        ShowMouse(FALSE);
      ELSIF my > work.h
      THEN
        (* Unterhalb von Work-Bereich, scrollen *)
        IF my - 2*charHeight > work.h
        THEN lines := 5
        ELSIF my - charHeight > work.h
        THEN lines := 3
        ELSE lines := 1
        END;
        HideMouse();
        WdwManager.ScrollDown (ed^.wdw, lines);
        ShowMouse (FALSE);
      END;
      IF (mx <= work.x) OR (mx <= 0)
      THEN
        (* Nach links scrollen *)
        IF (mx + 2*charWidth <= work.x)
        THEN lines := 5
        ELSIF (mx + charWidth <= work.x)
        THEN lines := 3
        ELSE lines := 1
        END;
        WdwManager.ScrollLeft (ed^.wdw, lines);
      ELSIF mx > work.w
      THEN
        (* Nach rechts scrollen *)
        IF (mx - 2*charWidth > work.w)
        THEN lines := 5
        ELSIF (mx - charWidth > work.w)
        THEN lines := 3
        ELSE lines := 1
        END;
        WdwManager.ScrollRight (ed^.wdw, lines);
      END; (* Bewegungsauswertung *)
      (* So, jetzt k”nnte es funktionieren *)
      GetClickLineAndRow (ed, mx, my, newLine, newRow);
      (* Jetzt haben wir Zeile und Spalte. Jetzt mssen noch die Nebenbedingungen
       * beachtet werden, d.h. Wort- bzw. Zeilenmarkierung
       * und das mindestens ein Wort bzw. eine Zeile markiert bleibt!
       *)
      IF wordBlock
      THEN
        (* Wordposition berechnen *)
        IF (newLine > saveStart.line) OR ((newLine = saveStart.line) & (newRow > saveStart.row))
        THEN
          newRow := ToWordEnd (ed, newLine, newRow);
        ELSE
          newRow := ToWordStart (ed, newLine, newRow);
        END;
      ELSIF lineBlock
      THEN
        (* Zeilenposition neu berechnen *)
        IF (newLine > saveStart.line)
        THEN
          INC (newLine);
        END;
        IF newLine >= totalLineNr
        THEN
          newRow := ToLineEnd (ed, totalLineNr-1);
          newLine := totalLineNr - 1;
        ELSE
          newRow := 0;
        END;
      END;
      newLine := BinOps.LowerLInt (totalLineNr-1, BinOps.HigherLInt (0, newLine));
      (* Jetzt feststellen, welche Marke neu gesetzt wird *)
      isRight := (newLine < saveStart.line) OR ((newLine = saveStart.line) & (newRow < saveStart.row));
      isLeft := (newLine > saveEnd.line) OR ((newLine = saveEnd.line) & (newRow > saveEnd.row));
      oldIsRight := (oldLine < saveStart.line) OR ((oldLine = saveStart.line) & (oldRow < saveStart.row));
      oldIsLeft := (oldLine > saveEnd.line) OR ((oldLine = saveEnd.line) & (oldRow > saveEnd.row));
      (* Jetzt haben wir die neuen Positionen, jetzt daraus die neuen
       * Pixelpositionen berechnen und dann vergleichen
       *)

      getCharPos (ed, newLine, newRow, newPixRow, v.int);
      IF isRight
      THEN
        IF oldIsRight
        THEN
          (* Einfach neuen Bereich markieren *)
          IF ((oldRow # newRow) OR (oldLine # newLine))(* & (oldLine >= 0) & (oldLine <= totalLineNr) *)
          THEN
            (* Es hat sich was ge„ndert, also mal neu zeichnen *)
            MarkArea (ed, oldLine, oldRow, newLine, newRow, TRUE);
          END;
        ELSIF oldIsLeft
        THEN
          (* Jetzt wird's spažiger, aber es hat sich garantiert was ge„ndert!
           *)
          MarkArea (ed, oldLine, oldRow, saveEnd.line, saveEnd.row, TRUE);
          MarkArea (ed, newLine, newRow, saveStart.line, saveStart.row, TRUE);
          newEnd.line := saveEnd.line;
          newEnd.row := saveEnd.row;
        ELSE
          (* Markieren von Blockanfang bis zu neuem Anfang *)
          MarkArea (ed, newLine, newRow, saveStart.line, saveStart.row, TRUE);
        END;
        newStart.row := newRow;
        newStart.line := newLine;
      ELSIF isLeft
      THEN
        IF oldIsLeft
        THEN
          (* Einfach neuen Bereich markieren *)
          IF ((oldRow # newRow) OR (oldLine # newLine))(* & (oldLine >= 0) & (oldLine <= totalLineNr) *)
          THEN
            (* Es hat sich was ge„ndert, also mal neu zeichnen *)
            MarkArea (ed, oldLine, oldRow, newLine, newRow, TRUE);
          END;
        ELSIF oldIsRight
        THEN
          (* Jetzt wird's spažiger, aber es hat sich garantiert was ge„ndert!
           *)
          MarkArea (ed, oldLine, oldRow, saveStart.line, saveStart.row, TRUE);
          MarkArea (ed, newLine, newRow, saveEnd.line, saveEnd.row, TRUE);
          newStart.line := saveStart.line;
          newStart.row := saveStart.row;
        ELSE
          (* Markieren von Blockende bis zu neuer Position *)
          MarkArea (ed, newLine, newRow, saveEnd.line, saveEnd.row, TRUE);
        END;
        newEnd.row := newRow;
        newEnd.line := newLine;
      ELSE
        (* in saveArea! *)
        IF oldIsRight
        THEN
          (* Bis zum Rand der Savearea markieren *)
          MarkArea (ed, oldLine, oldRow, saveStart.line, saveStart.row, TRUE);
          newStart.line := saveStart.line;
          newStart.row := saveStart.row;
        ELSIF oldIsLeft
        THEN
          MarkArea (ed, oldLine, oldRow, saveEnd.line, saveEnd.row, TRUE);
          newEnd.line := saveEnd.line;
          newEnd.row := saveEnd.row;
        ELSE
          (* old ist ebenfalls in SaveArea, do nothing! *)
        END;
      END;
      (* jetzt alte Werte sichern *)
      oldLine := newLine;
      oldRow := newRow;
      oldPixRow := newPixRow;
      blocks[0].blockStart := newStart;
      blocks[0].blockEnd   := newEnd;
      MagicAES.GrafMkstate (mx, my, b, v.bset);
    UNTIL ~(0 IN b);
    RestoreMouse();
    MagicAES.WindUpdate (MagicAES.ENDMCTRL);    (* Mauskontrolle wieder freigeben       *)
    ClipWork (ed);                              (* Und clipping wieder auf Workbereich  *)
    block := TRUE;
  END (* WITH ed^ *);
END MarkBlock;

PROCEDURE ToBlockmark (ed : EDITPTR; ende : BOOLEAN);
  VAR newLine : LONGINT;
      dir     : INTEGER;
      diff    : INTEGER;
BEGIN
  WITH ed^ DO
    IF ~block THEN RETURN END;
    HideMouse();
    HideCursor (ed);
    IF ende THEN
      SetCurrLine (ed, blocks[0].blockEnd.line);
      currRow := blocks[0].blockEnd.row;
    ELSE (* IF Ende *)
      SetCurrLine (ed, blocks[0].blockStart.line);
      currRow := blocks[0].blockStart.row;
    END;
    CenterCurrline (ed);
    ShowCursor(ed);
    ShowMouse (FALSE);
  END (* WITH ed^ DO *);
END ToBlockmark;

        (* Suchen und Ersetzen      *)

        (* Basisfunktionen fr Search and Replace *)

PROCEDURE InitSearch (ed: EDITPTR; direction: searchDir;
                      VAR search, repl: ARRAY OF CHAR; doRepl: BOOLEAN): BOOLEAN;
(* Compiliert das Suchmuster und setzt ein paar Variablen fr
 * Suchen & Ersetzen mit Wildcards, falls ersetzt werden soll
 * Gibt zurck, ob das Muster compiliert werden konnte.
 *)
 VAR
      gross:    BOOLEAN;
      up:       BOOLEAN;
      M:        INTEGER;
      i:        INTEGER;
      oneC,
      allC,
      wildC:    INTEGER;
BEGIN
  IF searchInited THEN EndSearch() END;
  M := (*SYSTEM.*)LENGTH (search); (* Anzahl der Zeichen im Suchstring *)

  (* Jetzt erstmal alle Wildcardzeichen am Anfang und am Ende l”schen,
   * die sind berflssig
   *)

  WHILE ((search [0] = EditTypes.wildOneChar)
         OR (search [0] = EditTypes.wildAllChar)) DO
    Strings.Delete (search, 0, 1, v.bool);
  END;
  M := (*SYSTEM.*)LENGTH (search); (* Anzahl der Zeichen im Suchstring *)
  WHILE (M > 1) & ((search[M-1] = EditTypes.wildAllChar) OR (search[M-1] = EditTypes.wildOneChar)) DO
    search[M-1] := 0c; DEC (M);
  END;

  M := (*SYSTEM.*)LENGTH (search); (* Anzahl der Zeichen im Suchstring *)

  IF M = 0 THEN RETURN FALSE END;

  up := direction = backward;
  (* Soll grož = klein sein? Wenn nicht gesetzt, dann ja! *)
  gross := (GrossKlein IN ed^.findMode);

  (* Suchmuster compilieren *)
  pPatt := Find2.Compile (search, EditTypes.wildOneChar, 1C, EditTypes.wildAllChar, 12C, gross, up);

  IF doRepl
  THEN
    (* Nach Wildcards im Suchstring suchen und Positionen merken *)
    oneC := 0;
    allC := 0;
    wildC := 1;
    FOR i := 0 TO M-1 DO
      IF search[i] = EditTypes.wildOneChar
      THEN
        oneWildNumbers[oneC] := wildC;
        INC (oneC);
        INC (wildC);
      ELSIF search[i] = EditTypes.wildAllChar
      THEN
        allWildNumbers[allC] := wildC;
        INC (allC);
        INC (wildC);
      END;
    END;
  END;
  searchInited := TRUE;
  RETURN pPatt # NIL;
END InitSearch;

PROCEDURE SearchWord (ed : EDITPTR; w: ARRAY OF CHAR;
                      direction : searchDir; VAR gefunden: BOOLEAN;
                      VAR foundWord: ARRAY OF CHAR; again : BOOLEAN);
(* Neue Suchroutine, benutzt jetzt Find-Modul von Andreas Alich. Reine Stringsuche
 * also ausgelagert.
 *)

VAR
      startx:   INTEGER;               (* Position, ab der in der
                                           Zeile gesucht werden soll *)
      findx:    INTEGER;               (* gefundene Position *)
      gross:    BOOLEAN;
      up:       BOOLEAN;

      M, j:     INTEGER;        (* M: Laenge des Suchstrings *)
      L:        INTEGER;        (* Laenge der untersuchten Zeile *)
      found:    BOOLEAN;        (* Suchstring gefunden? *)
      cLine:    LONGINT;        (* tempor„re Variable fr gefundene Zeilennummer *)
      cRow:     INTEGER;        (* tempor„re Variable fr gefundene Spaltennummer *)
      saveLine: LONGINT;
      saveRow : INTEGER;

  PROCEDURE WortTest (VAR s: ARRAY OF CHAR; cRow : INTEGER; wLen : INTEGER): BOOLEAN;
  VAR   links, rechts:  BOOLEAN;
  (* findx ist die Startposition des Suchstrings, findx + wLen - 1 die Endp. *)
  (* L ist die Laenge der untersuchten Zeile *)
  BEGIN
    IF ~(NurWort IN ed^.findMode) THEN
      RETURN TRUE;
    ELSE
      links := (cRow = 0) OR (s [cRow] IN TrennSet) OR
               (s [cRow - 1] IN TrennSet);
      IF ~links THEN RETURN FALSE
      ELSE
        rechts := (cRow + wLen > ed^.editLen) OR
                  (s [cRow + wLen - 1] IN TrennSet) OR
                  (s [cRow + wLen] IN TrennSet);
        RETURN rechts;
      END (* inneres IF *);
    END (* IF *);
  END WortTest;

VAR     d:      CHAR;

BEGIN (* SucheWort *)
  mtAppl.MouseOff();
  ClearBlock (ed);
  mtAppl.MouseOn();
  up := direction = backward;

  IF ~searchInited THEN gefunden := FALSE END;

  WITH ed^ DO
    (* Suchen in neuem Editor:
     * Suchen in jedem Buffer, ggf. Startposition und Buffer berechnen,
     * falls ab aktueller Zeile.
     * Wenn gefunden, dann nachprfen, ob gltig (in Block),
     * dann aus Offset Zeile und Spalte berechnen.
     *)
    saveLine := currLineNr;
    saveRow := currRow;
    startx := EditBase.GetOffset (ed);
    IF again THEN
      IF up THEN
        DEC (startx);
        IF startx < 0 THEN startx := 0; END;
      ELSE
        INC (startx)
      END;
    END;
    IF up
    THEN
      L := startx;
    ELSE
      L := currentBuff^.usedMem;
    END;
    found := FALSE;
    LOOP
      IF Find2.Find (currentBuff^.buffer, L, pPatt, startx)
      THEN
        (* neu:
    Falls das Muster gefunden wurde, sind die Eintr„ge 'len' und 'pMatch'
    in den tPat-Records gltig. 'pMatch' zeigt auf den Anfang des zum
    Teilmuster passenden Textteils. 'len' gibt die L„nge des Teilmusters an.
        *)
        findx := INTEGER(SHORT (LONGINT(ADDRESS(pPatt^.pFirst^.pMatch)-ADDRESS(currentBuff^.buffer))));

        EditBase.GetPos (ed, findx, cLine, cRow);
        SetCurrLine (ed, cLine);
        currRow := cRow;
        (* So, jetzt die L„nge des gefundenen Testes rausfinden und dann den Worttest machen! *)
        ptrPatt := pPatt^.pFirst;
        WHILE ptrPatt # NIL DO
          findx := INTEGER(SHORT (LONGINT(ADDRESS(ptrPatt^.pMatch)-ADDRESS(currentBuff^.buffer))));
          EditBase.GetPos (ed, findx, cLine, cRow);
          INC (cRow, INTEGER(ptrPatt^.len));
          ptrPatt := ptrPatt^.pNext;
        END;
        Strings.Copy (editLine.text^, currRow, cRow - currRow, foundWord, v.bool);
        IF WortTest (editLine.text^, currRow, cRow - currRow) THEN
          found := TRUE; EXIT
        END;
        findx := INTEGER(SHORT (LONGINT(ADDRESS(pPatt^.pFirst^.pMatch)-ADDRESS(currentBuff^.buffer))));
        IF up
        THEN
          startx := findx-1;
          IF startx < 0 THEN startx := 0; END;
        ELSE
          startx := findx+1;
        END;
      ELSE
        (* Nicht in dem Buffer gefunden *)
        IF up THEN
          IF currentBuff^.prev # NIL
          THEN
            currentBuff := currentBuff^.prev;
            startx := currentBuff^.usedMem;
            L := currentBuff^.usedMem;
          ELSE
            EXIT
          END;
        ELSE
          IF currentBuff^.next # NIL
          THEN
            currentBuff := currentBuff^.next;
            startx := 0;
            L := currentBuff^.usedMem;
          ELSE
            EXIT
          END;
        END;
      END;
    END (* LOOP *);

    IF found
    THEN
      IF ~(silent IN findMode)
      THEN
        mtAppl.MouseOff();
        (* Nicht globales Ersetzen, also Block markieren! *)
        SetBlockstart (ed);
        cRow := currRow;
        ptrPatt := pPatt^.pFirst;
        WHILE ptrPatt # NIL DO
          findx := INTEGER(SHORT (LONGINT(ADDRESS(ptrPatt^.pMatch)-ADDRESS(currentBuff^.buffer))));
          EditBase.GetPos (ed, findx, cLine, currRow);
          INC (currRow, INTEGER(ptrPatt^.len));
          ptrPatt := ptrPatt^.pNext;
        END;
        SetBlockend (ed);
        currRow := cRow;
        block := TRUE;
        CenterCurrline (ed);
        mtAppl.MouseOn();
      END;
    ELSE
      SetCurrLine (ed, saveLine);
      currRow := saveRow;
    END;
    gefunden := found;
  END (* WITH *);
END SearchWord;

PROCEDURE ReplaceWord (ed : EDITPTR; VAR s, t: ARRAY OF CHAR);
VAR     Zeile:  aLineDesc;
        sl, tl,
        zl, el: INTEGER;
(*$Reg*)tmpRow: INTEGER;
        i:      INTEGER;
        replW:  ARRAY [0..1023] OF CHAR;    (* L„nger kann unser Ersatzwort halt nicht werden *)
        numC:   CHAR;
        wIdx,
        pIdx,
        idx:    INTEGER;
        findx:  INTEGER;
        cLine:  LONGINT;
        cRow,
        clRow:  INTEGER;
BEGIN
  (* Erstmal Wildcards in t durch richtige Zeichen ersetzen *)
  tl := (*SYSTEM.*)LENGTH (t);
  tmpRow := 0;
  i := 0;
  WHILE i < tl DO
    IF (t[i] = EditTypes.wildOneChar)
    OR (t[i] = EditTypes.wildAllChar)
    THEN
      (* Ein-Zeichen-Wildcard gefunden *)
      numC := t[i+1];
      IF (numC >= '0') & (numC <= '9')
      THEN
        wIdx := INTEGER(ORD (numC) - ORD ('0'));
        (* Jetzt den Index in Patternliste rausfinden *)
        IF t[i] = EditTypes.wildOneChar
        THEN
          idx := oneWildNumbers[wIdx];
        ELSE
          idx := allWildNumbers[wIdx];
        END;
        INC (i);    (* Damit das Indexzeichen auch bersprungen wird *)
        (* Jetzt zum Ende des vorhergehenden Patterns gehen und dann
         * alle Zeichen bis zum Anfang des n„chsten Patterns in das Replaceword
         * setzen
         *)

        ptrPatt := pPatt^.pFirst;
        pIdx := 0;
        WHILE (ptrPatt # NIL) & (pIdx < idx) DO
          findx := INTEGER(SHORT (LONGINT(ADDRESS(ptrPatt^.pMatch)-ADDRESS(ed^.currentBuff^.buffer))));
          EditBase.GetPos (ed, findx, cLine, cRow);
          INC (cRow, INTEGER(ptrPatt^.len));
          ptrPatt := ptrPatt^.pNext;
          INC (pIdx);
        END;
        (* Jetzt haben wir die Position im Text, jetzt mssen wir nur noch herausfinden,
         * wieviele Zeichen wir kopieren k”nnen. Da es alles in einer Zeile ist,
         * kann ich zum rauskopieren auf editLine.text^ zugreifen!
         *)
        IF (ptrPatt # NIL)
        THEN
          (* Endposition steht praktisch schon in ptrPatt drin, muž nur ausgelesen
           * werden
           *)
          findx := INTEGER(SHORT (LONGINT(ADDRESS(ptrPatt^.pMatch)-ADDRESS(ed^.currentBuff^.buffer))));
          EditBase.GetPos (ed, findx, cLine, clRow);
          WHILE cRow < clRow DO
            replW[tmpRow] := ed^.editLine.text^[cRow];
            INC (cRow); INC (tmpRow);
          END;
        END;
      ELSE
        replW[tmpRow] := t[i];
        INC (tmpRow);
      END;
    ELSE
      replW[tmpRow] := t[i];
      INC (tmpRow);
    END;
    INC (i);
  END;
  replW[tmpRow] := 0c;

  (* ersetzt s durch replW in Zeile *)
  sl := (*SYSTEM.*)LENGTH (s);
  tl := (*SYSTEM.*)LENGTH (replW);
  WITH ed^ DO
    tmpRow := currRow;
    zl := editLen;
    el := zl + tl - sl;
    IF el >= editLine.length-1
    THEN
      el := ((el+16) DIV 16) * 16;
      IF el < 16 THEN el := 16 END;
      ALLOCATE (Zeile.text, el);
      IF Zeile.text = NIL
      THEN RETURN END;
      Zeile.length := el;
      Strings.Assign (editLine.text^, Zeile.text^, v.bool);
      Strings.Delete (Zeile.text^, tmpRow, sl, v.bool);
      Strings.Insert (replW, tmpRow, Zeile.text^, v.bool);
    ELSE
      WITH editLine DO
        Strings.Delete (text^, tmpRow, sl, v.bool);
        Strings.Insert (replW, tmpRow, text^, v.bool);
      END;
      el := -1
    END;
    editChanged := TRUE;
    ShowFileChanged(ed);
    IF el > 0
    THEN
      DEALLOCATE (editLine.text, 0);
      editLine.text := Zeile.text;
      editLine.length := Zeile.length;
    END;
    editLen := LENGTH (editLine.text^);
    v.bool := EditBase.PutCurrLine (ed);
    (* currRow hinter Wort setzen *)
    INC (currRow, tl);
    IF ~(silent IN findMode)
    THEN
      HideMouse();
      CenterCurrline (ed);
      ClearBlock (ed);
      drawLine (ed, SHORT(currLineNr - StartLine));
      ShowMouse(FALSE);
    END;
  END (* WITH ed *);
END ReplaceWord;

PROCEDURE EndSearch ();
(* Gibt das compilierte Suchmuster wieder frei
 *)
  VAR i : INTEGER;
BEGIN
  IF searchInited THEN
    Find2.Dispose (pPatt);
    searchInited := FALSE;
    FOR i := 0 TO 9 DO
      oneWildNumbers[i] := 0;
      allWildNumbers[i] := 0;
    END;
  END;
END EndSearch;

BEGIN
  searchInited := FALSE;
  undoList := NIL;
  NEW (saveLinePtr);
  IF saveLinePtr = NIL THEN HALT END;
  saveLinePtr^.zeile.length := 0;
  saveLinePtr^.zeile.text   := NIL;
  saveLineNr := -1;
  system := 0;
  undoBuffer.whatToUndo := nothingToDo;
  undoBuffer.buffer := NIL;
END EditTools.